#include "dri_usart.h"

// USART6 的变量
char usart6_rx_buffer[20];
int usart6_rx_index = 0;

// USART2 的变量
char usart2_rx_buffer[20];
int usart2_rx_index = 0;

void dri_usart6_init(void)
{
    GPIO_InitTypeDef   GPIO_InitStruct;
    USART_InitTypeDef  USART_InitStruct;
    NVIC_InitTypeDef   NVIC_InitStruct;
    
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOG, ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART6, ENABLE);

    GPIO_PinAFConfig(GPIOG, GPIO_PinSource9, GPIO_AF_USART6);
    GPIO_PinAFConfig(GPIOG, GPIO_PinSource14, GPIO_AF_USART6);
    
    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;
    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_9 | GPIO_Pin_14;
    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
    GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
    GPIO_Init(GPIOG, &GPIO_InitStruct);
    
    USART_InitStruct.USART_BaudRate = 115200;
    USART_InitStruct.USART_WordLength = USART_WordLength_8b;
    USART_InitStruct.USART_StopBits = USART_StopBits_1;
    USART_InitStruct.USART_Parity = USART_Parity_No;
    USART_InitStruct.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    USART_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_Init(USART6, &USART_InitStruct);

    USART_ITConfig(USART6, USART_IT_RXNE, ENABLE);
    NVIC_InitStruct.NVIC_IRQChannel = USART6_IRQn;
    NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1;
    NVIC_InitStruct.NVIC_IRQChannelSubPriority = 1;
    NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStruct);
    USART_ClearFlag(USART6, USART_FLAG_TC);
    USART_Cmd(USART6, ENABLE);
    
    // 初始化接收缓冲区
    memset(usart6_rx_buffer, 0, sizeof(usart6_rx_buffer));
    usart6_rx_index = 0;
}

void dri_usart2_init(void)
{
    GPIO_InitTypeDef   GPIO_InitStruct;
    USART_InitTypeDef  USART_InitStruct;
    NVIC_InitTypeDef   NVIC_InitStruct;
    
    // 使能 GPIOA 和 USART2 时钟
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);

    // 配置 PA2 和 PA3 为 USART2 功能
    GPIO_PinAFConfig(GPIOA, GPIO_PinSource2, GPIO_AF_USART2);
    GPIO_PinAFConfig(GPIOA, GPIO_PinSource3, GPIO_AF_USART2);
    
    // 初始化 GPIO
    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;
    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_2 | GPIO_Pin_3;  // PA2(TX), PA3(RX)
    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
    GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
    GPIO_Init(GPIOA, &GPIO_InitStruct);
    
    // 配置 USART2
    USART_InitStruct.USART_BaudRate = 115200;
    USART_InitStruct.USART_WordLength = USART_WordLength_8b;
    USART_InitStruct.USART_StopBits = USART_StopBits_1;
    USART_InitStruct.USART_Parity = USART_Parity_No;
    USART_InitStruct.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    USART_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_Init(USART2, &USART_InitStruct);

    // 使能接收中断
    USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
    
    // 配置 NVIC
    NVIC_InitStruct.NVIC_IRQChannel = USART2_IRQn;
    NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1;
    NVIC_InitStruct.NVIC_IRQChannelSubPriority = 2;  // 优先级与USART6不同
    NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStruct);
    
    // 清除标志位并使能 USART2
    USART_ClearFlag(USART2, USART_FLAG_TC);
    USART_Cmd(USART2, ENABLE);
    
    // 初始化接收缓冲区
    memset(usart2_rx_buffer, 0, sizeof(usart2_rx_buffer));
    usart2_rx_index = 0;
}

int fputc(int ch, FILE *f)
{
    // 默认使用 USART6 输出
    USART_SendData(USART6, ch);
    while(USART_GetFlagStatus(USART6, USART_FLAG_TC) == RESET);
    USART_ClearFlag(USART6, USART_FLAG_TC);
    return ch;
}

// USART2 专用的输出函数
void usart2_putc(char ch)
{
    USART_SendData(USART2, ch);
    while(USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET);
    USART_ClearFlag(USART2, USART_FLAG_TC);
	
}

void USART6_IRQHandler(void)
{
    char received_char = 0;
    if(USART_GetITStatus(USART6, USART_IT_RXNE))
    {    
        // 清除中断标志位
        USART_ClearITPendingBit(USART6, USART_IT_RXNE);
        
        // 读取接收到的字符
        received_char = USART_ReceiveData(USART6);
        
        // 回传接收到的字符
        USART_SendData(USART6, received_char);
        while(USART_GetFlagStatus(USART6, USART_FLAG_TC) == RESET);
        USART_ClearFlag(USART6, USART_FLAG_TC);
        
        // 处理接收到的字符
        if(usart6_rx_index < (sizeof(usart6_rx_buffer) - 1))
        {
            // 如果收到回车或换行符，处理命令
            if(received_char == '\r' || received_char == '\n')
            {
                usart6_rx_buffer[usart6_rx_index] = '\0'; // 确保字符串以null结尾
                
                // 处理命令
                if(strcmp(usart6_rx_buffer, "led_close") == 0)
                {
                    GPIO_SetBits(GPIOF, GPIO_Pin_8);
                }
                else if(strcmp(usart6_rx_buffer, "led_open") == 0)
                {
                    GPIO_ResetBits(GPIOF, GPIO_Pin_8);
                }
                else if(strcmp(usart6_rx_buffer, "fen_open") == 0)
                {
                    GPIO_SetBits(GPIOC, GPIO_Pin_6);
                }
                else if(strcmp(usart6_rx_buffer, "fen_close") == 0)
                {
                    GPIO_ResetBits(GPIOC, GPIO_Pin_6);
                }
                
                // 重置接收缓冲区和索引
                memset(usart6_rx_buffer, 0, sizeof(usart6_rx_buffer));
                usart6_rx_index = 0;
            }
            else
            {
                // 存储接收到的字符
                usart6_rx_buffer[usart6_rx_index++] = received_char;
            }
        }
        else
        {
            // 缓冲区已满，重置
            memset(usart6_rx_buffer, 0, sizeof(usart6_rx_buffer));
            usart6_rx_index = 0;
        }
    }
}

void USART2_IRQHandler(void)
{
    char received_char = 0;
    if(USART_GetITStatus(USART2, USART_IT_RXNE))
    {    
        // 清除中断标志位
        USART_ClearITPendingBit(USART2, USART_IT_RXNE);
        
        // 读取接收到的字符
        received_char = USART_ReceiveData(USART2);
        
        // 回传接收到的字符
        usart2_putc(received_char);
        
        // 处理接收到的字符
        if(usart2_rx_index < (sizeof(usart2_rx_buffer) - 1))
        {
            // 如果收到回车或换行符，处理命令
            if(received_char == '\r' || received_char == '\n')
            {
                usart2_rx_buffer[usart2_rx_index] = '\0'; // 确保字符串以null结尾
                
                // 处理命令
                if(strcmp(usart2_rx_buffer, "led_close") == 0)
                {
                    GPIO_SetBits(GPIOF, GPIO_Pin_8);
                }
                else if(strcmp(usart2_rx_buffer, "led_open") == 0)
                {
                    GPIO_ResetBits(GPIOF, GPIO_Pin_8);
                }
                else if(strcmp(usart2_rx_buffer, "fen_open") == 0)
                {
                   // GPIO_SetBits(GPIOC, GPIO_Pin_6);
					GPIO_SetBits(GPIOF, GPIO_Pin_8);
                }
                else if(strcmp(usart2_rx_buffer, "fen_close") == 0)
                {
                    //GPIO_ResetBits(GPIOC, GPIO_Pin_6);
					GPIO_ResetBits(GPIOF, GPIO_Pin_8);
                }
                
                // 重置接收缓冲区和索引
                memset(usart2_rx_buffer, 0, sizeof(usart2_rx_buffer));
                usart2_rx_index = 0;
            }
            else
            {
                // 存储接收到的字符
                usart2_rx_buffer[usart2_rx_index++] = received_char;
            }
        }
        else
        {
            // 缓冲区已满，重置
            memset(usart2_rx_buffer, 0, sizeof(usart2_rx_buffer));
            usart2_rx_index = 0;
        }
    }
}
//#include "dri_usart.h"
//char usart6_rx_buffer[20];
//int usart6_rx_index = 0;
//void dri_usart6_init(void)
//{
//	GPIO_InitTypeDef   GPIO_InitStruct;
//	USART_InitTypeDef  USART_InitStruct;
//	NVIC_InitTypeDef   NVIC_InitStruct;
//	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOG, ENABLE);
//	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART6, ENABLE);

//	GPIO_PinAFConfig(GPIOG, GPIO_PinSource9, GPIO_AF_USART6);
//	GPIO_PinAFConfig(GPIOG, GPIO_PinSource14, GPIO_AF_USART6);
//	
//	GPIO_InitStruct.GPIO_Mode=GPIO_Mode_AF;
//	GPIO_InitStruct.GPIO_Pin=GPIO_Pin_9|GPIO_Pin_14;
//	GPIO_InitStruct.GPIO_Speed=GPIO_Speed_50MHz;
//	GPIO_InitStruct.GPIO_OType=GPIO_OType_PP;
//	GPIO_InitStruct.GPIO_PuPd=GPIO_PuPd_UP;
//	GPIO_Init(GPIOG, &GPIO_InitStruct);
//	
//	USART_InitStruct.USART_BaudRate=115200;
//	USART_InitStruct.USART_WordLength=USART_WordLength_8b;
//	USART_InitStruct.USART_StopBits=USART_StopBits_1;
//	USART_InitStruct.USART_Parity=USART_Parity_No;
//	USART_InitStruct.USART_Mode=USART_Mode_Rx|USART_Mode_Tx;
//	USART_InitStruct.USART_HardwareFlowControl=USART_HardwareFlowControl_None;
//	USART_Init(USART6, &USART_InitStruct);

//	USART_ITConfig(USART6, USART_IT_RXNE, ENABLE);
//	NVIC_InitStruct.NVIC_IRQChannel=USART6_IRQn;
//	NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority=1;
//	NVIC_InitStruct.NVIC_IRQChannelSubPriority=1;
//	NVIC_InitStruct.NVIC_IRQChannelCmd=ENABLE;
//	NVIC_Init(&NVIC_InitStruct);
//	USART_ClearFlag(USART6, USART_FLAG_TC);
//	USART_Cmd(USART6, ENABLE);
//}
//int fputc(int ch, FILE *f)
//{
//	USART_SendData( USART6, ch);
//	while(USART_GetFlagStatus( USART6, USART_FLAG_TC)==RESET);
//	USART_ClearFlag(USART6, USART_FLAG_TC);
//	return ch;
//}
//void USART6_IRQHandler(void)
//{
//	char received_char=0;
//    if(USART_GetITStatus(USART6, USART_IT_RXNE))
//    {    
//        // 清除中断标志位
//        USART_ClearITPendingBit(USART6, USART_IT_RXNE);
//        
//        // 读取接收到的字符
//        received_char = USART_ReceiveData(USART6);
//        
//        // 回传接收到的字符
//        USART_SendData(USART6, received_char);
//        while(USART_GetFlagStatus(USART6, USART_FLAG_TC) == RESET);
//        USART_ClearFlag(USART6, USART_FLAG_TC);
//        
//        // 处理接收到的字符
//        if(usart6_rx_index < (sizeof(usart6_rx_buffer) - 1))
//        {
//            // 如果收到回车或换行符，处理命令
//            if(received_char == '\r' || received_char == '\n')
//            {
//                usart6_rx_buffer[usart6_rx_index] = '\0'; // 确保字符串以null结尾
//                
//                // 处理命令
//                if(strcmp(usart6_rx_buffer, "led_close") == 0)
//                {
//                    GPIO_SetBits(GPIOF, GPIO_Pin_8);
//                }
//                else if(strcmp(usart6_rx_buffer, "led_open") == 0)
//                {
//                    GPIO_ResetBits(GPIOF, GPIO_Pin_8);
//                }
//                else if(strcmp(usart6_rx_buffer, "fen_open") == 0)
//                {
//                    GPIO_SetBits(GPIOC, GPIO_Pin_6);
//                }
//                else if(strcmp(usart6_rx_buffer, "fen_close") == 0)
//                {
//                    GPIO_ResetBits(GPIOC, GPIO_Pin_6);
//                }
//                
//                // 重置接收缓冲区和索引
//                memset(usart6_rx_buffer, 0, sizeof(usart6_rx_buffer));
//                usart6_rx_index = 0;
//            }
//            else
//            {
//                // 存储接收到的字符
//                usart6_rx_buffer[usart6_rx_index++] = received_char;
//            }
//        }
//        else
//        {
//            // 缓冲区已满，重置
//            memset(usart6_rx_buffer, 0, sizeof(usart6_rx_buffer));
//            usart6_rx_index = 0;
//            
//            // 可选：发送错误提示
//           
//          
//        }
//    }
//}

